home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 26 / AACD 26.iso / AACD / Online / x3270 / unix_files / keymap.c < prev    next >
Encoding:
C/C++ Source or Header  |  2009-02-26  |  28.0 KB  |  1,229 lines
  1. /*
  2.  * Copyright 1996, 1999, 2000 by Paul Mattes.
  3.  *  Permission to use, copy, modify, and distribute this software and its
  4.  *  documentation for any purpose and without fee is hereby granted,
  5.  *  provided that the above copyright notice appear in all copies and that
  6.  *  both that copyright notice and this permission notice appear in
  7.  *  supporting documentation.
  8.  */
  9.  
  10. /*
  11.  *    keymap.c
  12.  *        This module handles keymaps.
  13.  */
  14.  
  15. #include "globals.h"
  16. #include <X11/IntrinsicP.h>
  17. #include <X11/Shell.h>
  18. #include <X11/StringDefs.h>
  19. #include <X11/Xaw/Command.h>
  20. #include <X11/Xaw/Form.h>
  21. #include <X11/Xaw/Label.h>
  22. #include <X11/Xaw/Text.h>
  23. #include <X11/Xaw/AsciiText.h>
  24. #include <X11/Xaw/AsciiSrc.h>
  25. #include <errno.h>
  26. #include "appres.h"
  27. #include "objects.h"
  28. #include "resources.h"
  29.  
  30. #include "hostc.h"
  31. #include "keymapc.h"
  32. #include "keypadc.h"
  33. #include "kybdc.h"
  34. #include "popupsc.h"
  35. #include "screenc.h"
  36. #include "statusc.h"
  37. #include "utilc.h"
  38.  
  39. #define PA_ENDL        " " PA_END "()"
  40.  
  41. Boolean keymap_changed = False;
  42. struct trans_list *trans_list = (struct trans_list *)NULL;
  43. static struct trans_list **last_trans = &trans_list;
  44. static struct trans_list *tkm_last;
  45. struct trans_list *temp_keymaps;    /* temporary keymap list */
  46. char *keymap_trace = CN;
  47. static char *last_keymap = CN;
  48. static Boolean last_nvt = False;
  49.  
  50. static void setup_keymaps(const char *km, Boolean do_popup);
  51. static void add_keymap(const char *name, Boolean do_popup);
  52. static void add_trans(const char *name, char *translations, char *pathname,
  53.     Boolean is_from_server);
  54. static char *get_file_keymap(const char *name, char **pathp);
  55. static void keymap_3270_mode(Boolean);
  56.  
  57. /* Undocumented Xt function to convert translations to text. */
  58. extern String _XtPrintXlations(Widget w, XtTranslations xlations,
  59.     Widget accelWidget, Boolean includeRHS);
  60.  
  61. extern Widget *screen;
  62.  
  63. #if defined(X3270_MENUS) /*[*/
  64. extern Pixmap diamond;
  65. extern Pixmap no_diamond;
  66.  
  67. static enum { SORT_EVENT, SORT_KEYMAP, SORT_ACTION } sort = SORT_KEYMAP;
  68.  
  69. static Boolean km_isup = False;
  70. static Widget km_shell, sort_event, sort_keymap, sort_action, text;
  71. static char km_file[128];
  72. static void create_text(void);
  73. static void km_up(Widget w, XtPointer client_data, XtPointer call_data);
  74. static void km_down(Widget w, XtPointer client_data, XtPointer call_data);
  75. static void km_done(Widget w, XtPointer client_data, XtPointer call_data);
  76. static void do_sort_action(Widget w, XtPointer client_data,
  77.     XtPointer call_data);
  78. static void do_sort_keymap(Widget w, XtPointer client_data,
  79.     XtPointer call_data);
  80. static void do_sort_event(Widget w, XtPointer client_data, XtPointer call_data);
  81. static void format_xlations(String s, FILE *f);
  82. static int action_cmp(char *s1, char *s2);
  83. static int keymap_cmp(char *k1, int l1, char *k2, int l2);
  84. static int event_cmp(char *e1, char *e2);
  85. static Boolean is_temp(char *k);
  86. static char *pathname(char *k);
  87. static Boolean from_server(char *k);
  88. static void km_regen(void);
  89. #else /*][*/
  90. #define km_regen()
  91. #endif /*]*/
  92.  
  93. /* Keymap initialization. */
  94. void
  95. keymap_init(const char *km)
  96. {
  97.     static Boolean initted = False;
  98.  
  99.     if (km == CN)
  100.         if ((km = (char *)getenv("KEYMAP")) == CN)
  101.             if ((km = (char *)getenv("KEYBD")) == CN)
  102.                 km = "@server";
  103.     setup_keymaps(km, initted);
  104.     if (!initted) {
  105.         initted = True;
  106.         last_nvt = IN_ANSI;
  107.         register_schange(ST_3270_MODE, keymap_3270_mode);
  108.         register_schange(ST_CONNECT, keymap_3270_mode);
  109.     } else {
  110.         screen_set_keymap();
  111.         keypad_set_keymap();
  112.     }
  113.     km_regen();
  114.  
  115.     /* Save the name(s) of the last keymap, so we can switch modes later. */
  116.     if (km != last_keymap) {
  117.         if (last_keymap != CN) {
  118.             Free(last_keymap);
  119.             last_keymap = CN;
  120.         }
  121.         if (km != CN)
  122.             last_keymap = NewString(km);
  123.     }
  124. }
  125.  
  126. /*
  127.  * 3270/NVT mode change.
  128.  */
  129. static void
  130. keymap_3270_mode(Boolean ignored unused)
  131. {
  132.     if (last_nvt != IN_ANSI) {
  133.         last_nvt = IN_ANSI;
  134.         keymap_init(last_keymap);
  135.     }
  136. }
  137.  
  138. /*
  139.  * Set up a user keymap.
  140.  */
  141. static void
  142. setup_keymaps(const char *km, Boolean do_popup)
  143. {
  144.     Boolean saw_apl_keymod = False;
  145.     struct trans_list *t;
  146.     struct trans_list *next;
  147.  
  148.     /* Make sure it starts with "base". */
  149.     if (km == CN)
  150.         km = "base";
  151.     else {
  152.         char *k = XtMalloc(5 + strlen(km) + 1);
  153.  
  154.         (void) sprintf(k, "base,%s", km);
  155.         km = k;
  156.     }
  157.  
  158.     if (do_popup)
  159.         keymap_changed = True;
  160.  
  161.     /* Clear out any existing translations. */
  162.     appres.key_map = (char *)NULL;
  163.     for (t = trans_list; t != (struct trans_list *)NULL; t = next) {
  164.         next = t->next;
  165.         XtFree(t->name);
  166.         if (t->pathname != CN)
  167.             XtFree(t->pathname);
  168.         XtFree((char *)t);
  169.     }
  170.     trans_list = (struct trans_list *)NULL;
  171.     last_trans = &trans_list;
  172.  
  173.     /* Build up the new list. */
  174.     if (km != CN) {
  175.         char *ns = XtNewString(km);
  176.         char *n0 = ns;
  177.         char *comma;
  178.  
  179.         do {
  180.             comma = strchr(ns, ',');
  181.             if (comma)
  182.                 *comma = '\0';
  183.             if (!strcmp(ns, Apl))
  184.                 saw_apl_keymod = True;
  185.             add_keymap(ns, do_popup);
  186.             if (comma)
  187.                 ns = comma + 1;
  188.             else
  189.                 ns = NULL;
  190.         } while (ns);
  191.  
  192.         XtFree(n0);
  193.     }
  194.     if (appres.apl_mode && !saw_apl_keymod)
  195.         add_keymap(Apl, do_popup);
  196. }
  197.  
  198. /*
  199.  * Get a keymap from a file.
  200.  */
  201. static char *
  202. get_file_keymap(const char *name, char **pathp)
  203. {
  204. #if 0
  205.     char *home;
  206. #endif
  207.     char *path;
  208.     XrmDatabase dd = (XrmDatabase)NULL;
  209.     char *resname;
  210.     XrmValue value;
  211.     char *type;
  212.     char *r = CN;
  213.  
  214.     *pathp = CN;
  215.  
  216. #if 0
  217.     /* Look for a user's keymap file. */
  218.     home = getenv("HOME");
  219.     if (home != CN) {
  220.         path = xs_buffer("%s/.x3270/keymap.%s", home, name);
  221.         dd = XrmGetFileDatabase(path);
  222.         if (dd != (XrmDatabase)NULL)
  223.             *pathp = path;
  224.         else
  225.             XtFree(path);
  226.     }
  227. #endif
  228.  
  229.     /* Look for a global keymap file. */
  230.     if (dd == (XrmDatabase)NULL) {
  231.         path = xs_buffer("%s/keymap.%s", LIBX3270DIR, name);
  232.         dd = XrmGetFileDatabase(path);
  233.         if (dd != (XrmDatabase)NULL)
  234.             *pathp = path;
  235.         else {
  236.             XtFree(path);
  237.             return CN;
  238.         }
  239.     }
  240.  
  241.     /* Look up the resource in that file. */
  242.     resname = xs_buffer("%s.%s.%s", XtName(toplevel), ResKeymap, name);
  243.     if ((XrmGetResource(dd, resname, 0, &type, &value) == True) &&
  244.             *value.addr) {
  245.         r = XtNewString(value.addr);
  246.     } else {
  247.         *pathp = CN;
  248.     }
  249.     XtFree(resname);
  250.     XrmDestroyDatabase(dd);
  251.     return r;
  252. }
  253.  
  254. /*
  255.  * Add to the list of user-specified keymap translations, finding both the
  256.  * system and user versions of a keymap.
  257.  */
  258. static void
  259. add_keymap(const char *name, Boolean do_popup)
  260. {
  261.     char *translations, *translations_nvt;
  262.     char *buf, *buf_nvt;
  263.     int any = 0;
  264.     char *path, *path_nvt;
  265.     Boolean is_from_server = False;
  266.  
  267.     if (appres.key_map == (char *)NULL)
  268.         appres.key_map = XtNewString(name);
  269.     else {
  270.         char *t = xs_buffer("%s,%s", appres.key_map, name);
  271.  
  272.         XtFree(appres.key_map);
  273.         appres.key_map = t;
  274.     }
  275.  
  276.     /* Translate '@server' to a vendor-specific keymap. */
  277.     if (!strcmp(name, "@server")) {
  278.         struct sk {
  279.             struct sk *next;
  280.             char *vendor;
  281.             char *keymap;
  282.         };
  283.         static struct sk *sk_list = (struct sk *)NULL;
  284.         struct sk *sk;
  285.  
  286.         if (sk_list == (struct sk *)NULL) {
  287.             char *s, *vendor, *keymap;
  288.  
  289.             s = get_resource("serverKeymapList");
  290.             if (s == CN)
  291.                 return;
  292.             s = XtNewString(s);
  293.             while (split_dresource(&s, &vendor, &keymap) == 1) {
  294.                 sk = (struct sk *)XtMalloc(sizeof(struct sk));
  295.                 sk->vendor = vendor;
  296.                 sk->keymap = keymap;
  297.                 sk->next = sk_list;
  298.                 sk_list = sk;
  299.             }
  300.         }
  301.         for (sk = sk_list; sk != (struct sk *)NULL; sk = sk->next) {
  302.             if (!strcmp(sk->vendor, ServerVendor(display))) {
  303.                 name = sk->keymap;
  304.                 is_from_server = True;
  305.                 break;
  306.             }
  307.         }
  308.         if (sk == (struct sk *)NULL)
  309.             return;
  310.     }
  311.  
  312.     /* Try for a file first, then resources. */
  313.     translations = get_file_keymap(name, &path);
  314.     buf_nvt = xs_buffer("%s.%s", name, ResNvt);
  315.     translations_nvt = get_file_keymap(buf_nvt, &path_nvt);
  316.     if (translations != CN || translations_nvt != CN) {
  317.         any++;
  318.         if (IN_ANSI && translations_nvt != CN)
  319.             add_trans(buf_nvt, translations_nvt, path_nvt,
  320.                 is_from_server);
  321.         else if (translations != CN)
  322.             add_trans(name, translations, path, is_from_server);
  323.         if (translations != CN)
  324.             XtFree(translations);
  325.         if (translations_nvt != CN)
  326.             XtFree(translations_nvt);
  327.         XtFree(buf_nvt);
  328.     } else {
  329.         XtFree(buf_nvt);
  330.  
  331.         /* Shared keymap. */
  332.         buf = xs_buffer("%s.%s", ResKeymap, name);
  333.         translations = get_resource(buf);
  334.         buf_nvt = xs_buffer("%s.%s.%s", ResKeymap, name, ResNvt);
  335.         translations_nvt = get_resource(buf_nvt);
  336.         if (translations != CN || translations_nvt != CN)
  337.             any++;
  338.         if (IN_ANSI && translations_nvt != CN)
  339.             add_trans(buf_nvt + strlen(ResKeymap) + 1,
  340.                 translations_nvt, CN, is_from_server);
  341.         else if (translations != CN)
  342.             add_trans(name, translations, CN, is_from_server);
  343.         XtFree(buf);
  344.         XtFree(buf_nvt);
  345.  
  346.         /* User keymap */
  347.         buf = xs_buffer("%s.%s.%s", ResKeymap, name, ResUser);
  348.         translations = get_resource(buf);
  349.         buf_nvt = xs_buffer("%s.%s.%s.%s", ResKeymap, name, ResNvt,
  350.             ResUser);
  351.         translations_nvt = get_resource(buf_nvt);
  352.         if (translations != CN || translations_nvt != CN)
  353.             any++;
  354.         if (IN_ANSI && translations_nvt != CN)
  355.             add_trans(buf_nvt + strlen(ResKeymap) + 1,
  356.                 translations_nvt, CN, is_from_server);
  357.         else if (translations != CN)
  358.             add_trans(buf, translations, CN, is_from_server);
  359.         XtFree(buf);
  360.         XtFree(buf_nvt);
  361.     }
  362.  
  363.     if (!any) {
  364.         if (do_popup)
  365.             popup_an_error("Cannot find %s \"%s\"", ResKeymap,
  366.                 name);
  367.         else
  368.             xs_warning("Cannot find %s \"%s\"", ResKeymap, name);
  369.     }
  370. }
  371.  
  372. /*
  373.  * Add a single keymap name and translation to the translation list.
  374.  */
  375. static void
  376. add_trans(const char *name, char *translations, char *path_name,
  377.     Boolean is_from_server)
  378. {
  379.     struct trans_list *t;
  380.  
  381.     t = (struct trans_list *)XtMalloc(sizeof(*t));
  382.     t->name = XtNewString(name);
  383.     t->pathname = path_name;
  384.     t->is_temp = False;
  385.     t->from_server = is_from_server;
  386.     (void) lookup_tt(name, translations);
  387.     t->next = NULL;
  388.     *last_trans = t;
  389.     last_trans = &t->next;
  390. }
  391.  
  392. /*
  393.  * Translation table expansion.
  394.  */
  395.  
  396. /* Find the first unquoted newline an an action list. */
  397. static char *
  398. unquoted_newline(char *s)
  399. {
  400.     Boolean bs = False;
  401.     enum { UQ_BASE, UQ_PLIST, UQ_Q } state = UQ_BASE;
  402.     char c;
  403.  
  404.     for ( ; (c = *s); s++) {
  405.         if (bs) {
  406.             bs = False;
  407.             continue;
  408.         } else if (c == '\\') {
  409.             bs = True;
  410.             continue;
  411.         }
  412.         switch (state) {
  413.             case UQ_BASE:
  414.             if (c == '(')
  415.                 state = UQ_PLIST;
  416.             else if (c == '\n')
  417.                 return s;
  418.             break;
  419.             case UQ_PLIST:
  420.             if (c == ')')
  421.                 state = UQ_BASE;
  422.             else if (c == '"')
  423.                 state = UQ_Q;
  424.             break;
  425.             case UQ_Q:
  426.             if (c == '"')
  427.                 state = UQ_PLIST;
  428.             break;
  429.         }
  430.     }
  431.     return CN;
  432. }
  433.  
  434. /* Expand a translation table with keymap tracing calls. */
  435. static char *
  436. expand_table(const char *name, char *table)
  437. {
  438.     char *cm, *t0, *t, *s;
  439.     int nlines = 1;
  440.  
  441.     if (table == CN)
  442.         return CN;
  443.  
  444.     /* Roughly count the number of lines in the table. */
  445.     cm = table;
  446.     while ((cm = strchr(cm, '\n')) != CN) {
  447.         nlines++;
  448.         cm++;
  449.     }
  450.  
  451.     /* Allocate a new buffer. */
  452.     t = t0 = (char *)XtMalloc(2 + strlen(table) +
  453.         nlines * (strlen(" " PA_KEYMAP_TRACE "(,nnnn) ") + strlen(name) +
  454.               strlen(PA_ENDL)));
  455.     *t = '\0';
  456.  
  457.     /* Expand the table into it. */
  458.     s = table;
  459.     nlines = 0;
  460.     while (*s) {
  461.         /* Skip empty lines. */
  462.         while (*s == ' ' || *s == '\t')
  463.             s++;
  464.         if (*s == '\n') {
  465.             *t++ = '\n';
  466.             *t = '\0';
  467.             s++;
  468.             continue;
  469.         }
  470.  
  471.         /* Find the '>' from the event name, and copy up through it. */
  472.         cm = strchr(s, '>');
  473.         if (cm == CN) {
  474.             while ((*t++ = *s++))
  475.                 ;
  476.             break;
  477.         }
  478.         while (s <= cm)
  479.             *t++ = *s++;
  480.  
  481.         /* Find the ':' following, and copy up throught that. */
  482.         cm = strchr(s, ':');
  483.         if (cm == CN) {
  484.             while ((*t++ = *s++))
  485.                 ;
  486.             break;
  487.         }
  488.         nlines++;
  489.         while (s <= cm)
  490.             *t++ = *s++;
  491.  
  492. #if defined(X3270_TRACE) /*[*/
  493.         /* Insert a PA-KeymapTrace call. */
  494.         (void) sprintf(t, " " PA_KEYMAP_TRACE "(%s,%d) ", name, nlines);
  495.         t = strchr(t, '\0');
  496. #endif /*]*/
  497.  
  498.         /*
  499.          * Copy to the next unquoted newline and append a PA-End call.
  500.          */
  501.         cm = unquoted_newline(s);
  502.         if (cm == CN) {
  503.             while ((*t = *s)) {
  504.                 t++;
  505.                 s++;
  506.             }
  507.         } else {
  508.             while (s < cm)
  509.                 *t++ = *s++;
  510.         }
  511. #if defined(X3270_TRACE) /*[*/
  512.         (void) strcpy(t, PA_ENDL);
  513.         t += strlen(PA_ENDL);
  514. #endif /*]*/
  515.         if (cm == CN)
  516.             break;
  517.         else
  518.             *t++ = *s++;
  519.     }
  520.     *t = '\0';
  521.  
  522.     return t0;
  523. }
  524.  
  525. #if defined(X3270_TRACE) /*[*/
  526. /*
  527.  * Trace a keymap.
  528.  *
  529.  * This function leaves a value in the global "keymap_trace", which is used
  530.  * by the action_debug function when subsequent actions are called.
  531.  */
  532. void
  533. PA_KeymapTrace_action(Widget w unused, XEvent *event unused, String *params,
  534.     Cardinal *num_params)
  535. {
  536.     if (!toggled(EVENT_TRACE) || *num_params != 2)
  537.         return;
  538.     if (keymap_trace != CN)
  539.         XtFree((XtPointer)keymap_trace);
  540.     keymap_trace = XtMalloc(strlen(params[0]) + 1 + strlen(params[1]) + 1);
  541.     (void) sprintf(keymap_trace, "%s:%s", params[0], params[1]);
  542. }
  543. #endif /*]*/
  544.  
  545. /*
  546.  * End a keymap trace.
  547.  *
  548.  * This function clears the value in the global "keymap_trace".
  549.  */
  550. void
  551. PA_End_action(Widget w unused, XEvent *event unused, String *params unused,
  552.     Cardinal *num_params unused)
  553. {
  554.     if (keymap_trace != CN)
  555.         XtFree((XtPointer)keymap_trace);
  556.     keymap_trace = CN;
  557. }
  558.  
  559. /*
  560.  * Translation table cache.
  561.  */
  562. XtTranslations
  563. lookup_tt(const char *name, char *table)
  564. {
  565.     struct tt_cache {
  566.         char *name;
  567.         XtTranslations trans;
  568.         struct tt_cache *next;
  569.     };
  570. #    define TTN (struct tt_cache *)NULL
  571.     static struct tt_cache *tt_cache = TTN;
  572.     struct tt_cache *t;
  573.     char *xtable;
  574.  
  575.     /* Look for an old one. */
  576.     for (t = tt_cache; t != TTN; t = t->next)
  577.         if (!strcmp(name, t->name))
  578.             return t->trans;
  579.  
  580.     /* Allocate and translate a new one. */
  581.     t = (struct tt_cache *)XtMalloc(sizeof(*t));
  582.     t->name = XtNewString(name);
  583.     xtable = expand_table(name, table);
  584.     t->trans = XtParseTranslationTable(xtable);
  585.     XtFree((XtPointer)xtable);
  586.     t->next = tt_cache;
  587.     tt_cache = t;
  588.  
  589.     return t->trans;
  590. }
  591. #undef TTN
  592.  
  593. /*
  594.  * Set or clear a temporary keymap.
  595.  *
  596.  * If the parameter is CN, removes all keymaps.
  597.  * Otherwise, toggles the keymap by that name.
  598.  *
  599.  * Returns 0 if the action was successful, -1 otherwise.
  600.  *
  601.  */
  602. int
  603. temporary_keymap(char *k)
  604. {
  605.     char *kmname, *km;
  606.     XtTranslations trans;
  607.     struct trans_list *t, *prev;
  608.     char *path = CN;
  609. #    define TN (struct trans_list *)NULL
  610.  
  611.     if (k == CN) {
  612.         struct trans_list *next;
  613.  
  614.         /* Delete all temporary keymaps. */
  615.         for (t = temp_keymaps; t != TN; t = next) {
  616.             XtFree((XtPointer)t->name);
  617.             if (t->pathname != CN)
  618.                 XtFree((XtPointer)t->pathname);
  619.             next = t->next;
  620.             XtFree((XtPointer)t);
  621.         }
  622.         tkm_last = temp_keymaps = TN;
  623.         screen_set_temp_keymap((XtTranslations)NULL);
  624.         keypad_set_temp_keymap((XtTranslations)NULL);
  625.         status_kmap(False);
  626.         km_regen();
  627.         return 0;
  628.     }
  629.  
  630.     /* Check for deleting one keymap. */
  631.     for (prev = TN, t = temp_keymaps; t != TN; prev = t, t = t->next)
  632.         if (!strcmp(k, t->name))
  633.             break;
  634.     if (t != TN) {
  635.  
  636.         /* Delete the keymap from the list. */
  637.         if (prev != TN)
  638.             prev->next = t->next;
  639.         else
  640.             temp_keymaps = t->next;
  641.         if (tkm_last == t)
  642.             tkm_last = prev;
  643.         XtFree((XtPointer)t->name);
  644.         XtFree((XtPointer)t);
  645.  
  646.         /* Rebuild the translation tables from the remaining ones. */
  647.         screen_set_temp_keymap((XtTranslations)NULL);
  648.         keypad_set_temp_keymap((XtTranslations)NULL);
  649.         for (t = temp_keymaps; t != TN; t = t->next) {
  650.             trans = lookup_tt(t->name, CN);
  651.             screen_set_temp_keymap(trans);
  652.             keypad_set_temp_keymap(trans);
  653.         }
  654.  
  655.         /* Update the status line. */
  656.         if (temp_keymaps == TN)
  657.             status_kmap(False);
  658.         km_regen();
  659.         return 0;
  660.     }
  661.  
  662.     /* Add a keymap. */
  663.  
  664.     /* Try a file first. */
  665.     km = get_file_keymap(k, &path);
  666.     if (km == CN) {
  667.         /* Then try a resource. */
  668.         kmname = xs_buffer("%s.%s", ResKeymap, k);
  669.         km = get_resource(kmname);
  670.         XtFree(kmname);
  671.         if (km == CN)
  672.             return -1;
  673.     }
  674.  
  675.     /* Update the translation tables. */
  676.     trans = lookup_tt(k, km);
  677.     screen_set_temp_keymap(trans);
  678.     keypad_set_temp_keymap(trans);
  679.  
  680.     /* Add it to the list. */
  681.     t = (struct trans_list *)XtMalloc(sizeof(*t));
  682.     t->name = XtNewString(k);
  683.     t->pathname = path;
  684.     t->is_temp = True;
  685.     t->from_server = False;
  686.     t->next = TN;
  687.     if (tkm_last != TN)
  688.         tkm_last->next = t;
  689.     else
  690.         temp_keymaps = t;
  691.     tkm_last = t;
  692.  
  693.     /* Update the status line. */
  694.     status_kmap(True);
  695.     km_regen();
  696.  
  697.     /* Success. */
  698.     return 0;
  699. }
  700. #undef TN
  701.  
  702. #if defined(X3270_MENUS) /*[*/
  703. /* Create and pop up the current keymap pop-up. */
  704. void
  705. do_keymap_display(Widget w unused, XtPointer userdata unused,
  706.     XtPointer calldata unused)
  707. {
  708.     Widget form, label, done;
  709.  
  710.     /* Create the popup. */
  711.     km_shell = XtVaCreatePopupShell(
  712.         "kmPopup", transientShellWidgetClass, toplevel,
  713.         NULL);
  714.     XtAddCallback(km_shell, XtNpopupCallback, place_popup,
  715.         (XtPointer) CenterP);
  716.     XtAddCallback(km_shell, XtNpopupCallback, km_up, (XtPointer)NULL);
  717.     XtAddCallback(km_shell, XtNpopdownCallback, km_down, (XtPointer)NULL);
  718.  
  719.     /* Create a form in the popup. */
  720.     form = XtVaCreateManagedWidget(
  721.         ObjDialog, formWidgetClass, km_shell,
  722.         NULL);
  723.  
  724.     /* Create the title. */
  725.     label = XtVaCreateManagedWidget("label", labelWidgetClass, form,
  726.         XtNborderWidth, 0,
  727.         NULL);
  728.  
  729.     /* Create the options. */
  730.     sort_event = XtVaCreateManagedWidget("sortEventOption",
  731.         commandWidgetClass, form,
  732.         XtNborderWidth, 0,
  733.         XtNfromVert, label,
  734.         XtNleftBitmap, sort == SORT_EVENT ? diamond : no_diamond,
  735.         NULL);
  736.     XtAddCallback(sort_event, XtNcallback, do_sort_event,
  737.         (XtPointer)NULL);
  738.     sort_keymap = XtVaCreateManagedWidget("sortKeymapOption",
  739.         commandWidgetClass, form,
  740.         XtNborderWidth, 0,
  741.         XtNfromVert, sort_event,
  742.         XtNleftBitmap, sort == SORT_KEYMAP ? diamond : no_diamond,
  743.         NULL);
  744.     XtAddCallback(sort_keymap, XtNcallback, do_sort_keymap,
  745.         (XtPointer)NULL);
  746.     sort_action = XtVaCreateManagedWidget("sortActionOption",
  747.         commandWidgetClass, form,
  748.         XtNborderWidth, 0,
  749.         XtNfromVert, sort_keymap,
  750.         XtNleftBitmap, sort == SORT_ACTION ? diamond : no_diamond,
  751.         NULL);
  752.     XtAddCallback(sort_action, XtNcallback, do_sort_action,
  753.         (XtPointer)NULL);
  754.  
  755.     /* Create a text widget attached to the file. */
  756.     text = XtVaCreateManagedWidget(
  757.         "text", asciiTextWidgetClass, form,
  758.         XtNfromVert, sort_action,
  759.         XtNscrollHorizontal, XawtextScrollAlways,
  760.         XtNscrollVertical, XawtextScrollAlways,
  761.         XtNdisplayCaret, False,
  762.         NULL);
  763.     create_text();
  764.  
  765.     /* Create the Done button. */
  766.     done = XtVaCreateManagedWidget(ObjConfirmButton,
  767.         commandWidgetClass, form,
  768.         XtNfromVert, text,
  769.         NULL);
  770.     XtAddCallback(done, XtNcallback, km_done, (XtPointer)NULL);
  771.  
  772.     /* Pop it up. */
  773.     popup_popup(km_shell, XtGrabNone);
  774. }
  775.  
  776. /* Format the keymap into a text source. */
  777. static void
  778. create_text(void)
  779. {
  780.     String s;
  781.     FILE *f;
  782.     Widget source, old;
  783.  
  784.     /* Ready a file. */
  785.     (void) sprintf(km_file, "/tmp/km.%d", getpid());
  786.     f = fopen(km_file, "w");
  787.     if (f == (FILE *)NULL) {
  788.         popup_an_errno(errno, "temporary file open");
  789.         return;
  790.     }
  791.  
  792.     s = _XtPrintXlations(*screen, (*screen)->core.tm.translations, NULL,
  793.         True);
  794.     format_xlations(s, f);
  795.     XtFree(s);
  796.     fclose(f);
  797.     source = XtVaCreateWidget(
  798.         "source", asciiSrcObjectClass, text,
  799.         XtNtype, XawAsciiFile,
  800.         XtNstring, km_file,
  801.         XtNeditType, XawtextRead,
  802.         NULL);
  803.     old = XawTextGetSource(text);
  804.     XawTextSetSource(text, source, (XawTextPosition)0);
  805.     XtDestroyWidget(old);
  806. }
  807.  
  808. /* Refresh the keymap display, if it's up. */
  809. static void
  810. km_regen(void)
  811. {
  812.     if (km_isup)
  813.         create_text();
  814. }
  815.  
  816. /* Popup callback. */
  817. static void
  818. km_up(Widget w unused, XtPointer client_data unused, XtPointer call_data unused)
  819. {
  820.     km_isup = True;
  821. }
  822.  
  823. /* Popdown callback.  Destroy the widget. */
  824. static void
  825. km_down(Widget w unused, XtPointer client_data unused,
  826.     XtPointer call_data unused)
  827. {
  828.     km_isup = False;
  829.     (void) unlink(km_file);
  830.     XtDestroyWidget(km_shell);
  831. }
  832.  
  833. /* Done button callback.  Pop down the widget. */
  834. static void
  835. km_done(Widget w unused, XtPointer client_data unused,
  836.     XtPointer call_data unused)
  837. {
  838.     XtPopdown(km_shell);
  839. }
  840.  
  841. /* "Sort-by-event" button callback. */
  842. static void
  843. do_sort_event(Widget w unused, XtPointer client_data unused,
  844.     XtPointer call_data unused)
  845. {
  846.     if (sort != SORT_EVENT) {
  847.         sort = SORT_EVENT;
  848.         XtVaSetValues(sort_action, XtNleftBitmap, no_diamond, NULL);
  849.         XtVaSetValues(sort_keymap, XtNleftBitmap, no_diamond, NULL);
  850.         XtVaSetValues(sort_event, XtNleftBitmap, diamond, NULL);
  851.         create_text();
  852.     }
  853. }
  854.  
  855. /* "Sort-by-keymap" button callback. */
  856. static void
  857. do_sort_keymap(Widget w unused, XtPointer client_data unused,
  858.     XtPointer call_data unused)
  859. {
  860.     if (sort != SORT_KEYMAP) {
  861.         sort = SORT_KEYMAP;
  862.         XtVaSetValues(sort_action, XtNleftBitmap, no_diamond, NULL);
  863.         XtVaSetValues(sort_keymap, XtNleftBitmap, diamond, NULL);
  864.         XtVaSetValues(sort_event, XtNleftBitmap, no_diamond, NULL);
  865.         create_text();
  866.     }
  867. }
  868.  
  869. /* "Sort-by-action" button callback. */
  870. static void
  871. do_sort_action(Widget w unused, XtPointer client_data unused,
  872.     XtPointer call_data unused)
  873. {
  874.     if (sort != SORT_ACTION) {
  875.         sort = SORT_ACTION;
  876.         XtVaSetValues(sort_action, XtNleftBitmap, diamond, NULL);
  877.         XtVaSetValues(sort_keymap, XtNleftBitmap, no_diamond, NULL);
  878.         XtVaSetValues(sort_event, XtNleftBitmap, no_diamond, NULL);
  879.         create_text();
  880.     }
  881. }
  882.  
  883. #define DASHES \
  884.     "-------------------------- ---------------- ------------------------------------"
  885.  
  886. /*
  887.  * Format translations for display.
  888.  *
  889.  * The data from _XtPrintXlations looks like this:
  890.  *  [<space>]event:<space>[PA-KeymapTrace("keymap","line")<space>][action...]
  891.  * with the delightful complication that embedded quotes are not quoted.
  892.  *
  893.  * What we want to do is to:
  894.  *  remove all lines without PA-KeymapTrace
  895.  *  remove the leading space
  896.  *  sort by actions list
  897.  *  reformat as:
  898.  *    action... event (keymap:line)
  899.  */
  900. static void
  901. format_xlations(String s, FILE *f)
  902. {
  903.     char *t;
  904.     char *t_next;
  905.     struct xl {
  906.         struct xl *next;
  907.         char *actions;
  908.         char *event;
  909.         char *keymap;
  910.         int km_line;
  911.         char *full_keymap;
  912.     } *xl_list = (struct xl *)NULL, *x, *xs, *xlp, *xn;
  913.     char *km_last;
  914.     int line_last = 0;
  915.  
  916.     /* Construct the list. */
  917.     for (t = s; t != CN; t = t_next) {
  918.         char *k, *a, *kk;
  919.         int nq;
  920.         static char cmps[] = ": " PA_KEYMAP_TRACE "(";
  921.  
  922.         /* Find the end of this rule and terminate this line. */
  923.         t_next = strstr(t, PA_ENDL "\n");
  924.         if (t_next != CN) {
  925.             t_next += strlen(PA_ENDL);
  926.             *t_next++ = '\0';
  927.         }
  928.  
  929.         /* Remove the leading space. */
  930.         while (*t == ' ')
  931.             t++;
  932.  
  933.         /* Use only traced events. */
  934.         k = strstr(t, cmps);
  935.         if (k == CN)
  936.             continue;
  937.         *k = '\0';
  938.         k += strlen(cmps);
  939.  
  940.         /* Find the rest of the actions. */
  941.         a = strchr(k, ')');
  942.         if (a == CN)
  943.             continue;
  944.         while (*(++a) == ' ')
  945.             ;
  946.         if (!*a)
  947.             continue;
  948.  
  949.         /* Remove the trailing PA-End call. */
  950.         if (strlen(a) >= strlen(PA_ENDL) &&
  951.             !strcmp(a + strlen(a) - strlen(PA_ENDL), PA_ENDL))
  952.             a[strlen(a) - strlen(PA_ENDL)] = '\0';
  953.  
  954.         /* Allocate the new element. */
  955.         x = (struct xl *)XtCalloc(sizeof(struct xl), 1);
  956.         x->actions = XtNewString(a);
  957.         x->event = XtNewString(t);
  958.         x->keymap = kk = (char *)XtMalloc(a - k + 1);
  959.         x->km_line = 0;
  960.         x->full_keymap = (char *)XtMalloc(a - k + 1);
  961.         nq = 0;
  962.         while (*k != ')') {
  963.             if (*k == '"') {
  964.                 nq++;
  965.             } else if (nq == 1) {
  966.                 *kk++ = *k;
  967.             } else if (nq == 3) {
  968.                 x->km_line = atoi(k);
  969.                 break;
  970.             }
  971.             k++;
  972.         }
  973.         *kk = '\0';
  974.         (void) sprintf(x->full_keymap, "%s:%d", x->keymap, x->km_line);
  975.  
  976.         /* Find where it should be inserted. */
  977.         for (xs = xl_list, xlp = (struct xl *)NULL;
  978.              xs != (struct xl *)NULL;
  979.              xlp = xs, xs = xs->next) {
  980.             int halt = 0;
  981.  
  982.             switch (sort) {
  983.                 case SORT_EVENT:
  984.                 halt = (event_cmp(xs->event, x->event) > 0);
  985.                 break;
  986.                 case SORT_KEYMAP:
  987.                 halt = (keymap_cmp(xs->keymap, xs->km_line,
  988.                            x->keymap, x->km_line) > 0);
  989.                 break;
  990.                 case SORT_ACTION:
  991.                 halt = (action_cmp(xs->actions, a) > 0);
  992.                 break;
  993.             }
  994.             if (halt)
  995.                 break;
  996.         }
  997.  
  998.         /* Insert it. */
  999.         if (xlp != (struct xl *)NULL) {
  1000.             x->next = xlp->next;
  1001.             xlp->next = x;
  1002.         } else {
  1003.             x->next = xl_list;
  1004.             xl_list = x;
  1005.         }
  1006.     }
  1007.  
  1008.     /* Walk it. */
  1009.     if (sort != SORT_KEYMAP)
  1010.         (void) fprintf(f, "%-26s %-16s %s\n%s\n",
  1011.             get_message("kmEvent"),
  1012.             get_message("kmKeymapLine"),
  1013.             get_message("kmActions"),
  1014.             DASHES);
  1015.     km_last = CN;
  1016.     for (xs = xl_list; xs != (struct xl *)NULL; xs = xs->next) {
  1017.         switch (sort) {
  1018.             case SORT_EVENT:
  1019.             if (km_last != CN) {
  1020.                 char *l;
  1021.  
  1022.                 l = strchr(xs->event, '<');
  1023.                 if (l != CN) {
  1024.                     if (strcmp(km_last, l))
  1025.                         (void) fprintf(f, "\n");
  1026.                     km_last = l;
  1027.                 }
  1028.             } else
  1029.                 km_last = strchr(xs->event, '<');
  1030.             break;
  1031.             case SORT_KEYMAP:
  1032.             if (km_last == CN || strcmp(xs->keymap, km_last)) {
  1033.                 char *p;
  1034.  
  1035.                 (void) fprintf(f, "%s%s '%s'%s",
  1036.                     km_last == CN ? "" : "\n",
  1037.                     get_message(is_temp(xs->keymap) ?
  1038.                             "kmTemporaryKeymap" :
  1039.                             "kmKeymap"),
  1040.                     xs->keymap,
  1041.                     from_server(xs->keymap) ?
  1042.                     get_message("kmFromServer") : "");
  1043.                 if ((p = pathname(xs->keymap)) != CN)
  1044.                     (void) fprintf(f, ", %s %s",
  1045.                         get_message("kmFile"), p);
  1046.                 else
  1047.                     (void) fprintf(f,
  1048.                         ", %s %s.%s.%s",
  1049.                         get_message("kmResource"),
  1050.                         programname, ResKeymap, xs->keymap);
  1051.                 (void) fprintf(f,
  1052.                     "\n%-26s %-16s %s\n%s\n",
  1053.                     get_message("kmEvent"),
  1054.                     get_message("kmKeymapLine"),
  1055.                     get_message("kmActions"),
  1056.                     DASHES);
  1057.                 km_last = xs->keymap;
  1058.                 line_last = 0;
  1059.             }
  1060.             while (xs->km_line != ++line_last) {
  1061.                 (void) fprintf(f, "%-26s %s:%d\n",
  1062.                     get_message("kmOverridden"),
  1063.                     xs->keymap, line_last);
  1064.             }
  1065.             break;
  1066.             case SORT_ACTION:
  1067.             break;
  1068.         }
  1069.         (void) fprintf(f, "%-26s %-16s ",
  1070.             xs->event, xs->full_keymap);
  1071.         (void) fcatv(f, xs->actions);
  1072.         (void) fputc('\n', f);
  1073.     }
  1074.  
  1075.     /* Free it. */
  1076.     for (xs = xl_list; xs != (struct xl *)NULL; xs = xn) {
  1077.         xn = xs->next;
  1078.         XtFree((XtPointer)xs->actions);
  1079.         XtFree((XtPointer)xs->event);
  1080.         XtFree((XtPointer)xs->keymap);
  1081.         XtFree((XtPointer)xs->full_keymap);
  1082.         XtFree((XtPointer)xs);
  1083.     }
  1084. }
  1085.  
  1086. /*
  1087.  * Comparison function for actions.  Basically, a strcmp() that handles "PF"
  1088.  * and "PA" specially.
  1089.  */
  1090. #define PA    "PA("
  1091. #define PF    "PF("
  1092. static int
  1093. action_cmp(char *s1, char *s2)
  1094. {
  1095.     if ((!strncmp(s1, PA, 3) && !strncmp(s2, PA, 3)) ||
  1096.         (!strncmp(s1, PF, 3) && !strncmp(s2, PF, 3)))
  1097.         return atoi(s1 + 4) - atoi(s2 + 4);
  1098.     else
  1099.         return strcmp(s1, s2);
  1100.         
  1101. }
  1102.  
  1103. /* Return a keymap's index in the lists. */
  1104. static int
  1105. km_index(char *n)
  1106. {
  1107.     struct trans_list *t;
  1108.     int ix = 0;
  1109.  
  1110.     for (t = trans_list; t != (struct trans_list *)NULL; t = t->next) {
  1111.         if (!strcmp(t->name, n))
  1112.             return ix;
  1113.         ix++;
  1114.     }
  1115.     for (t = temp_keymaps; t != (struct trans_list *)NULL; t = t->next) {
  1116.         if (!strcmp(t->name, n))
  1117.             return ix;
  1118.         ix++;
  1119.     }
  1120.     return ix;
  1121. }
  1122.  
  1123. /* Return whether or not a keymap is temporary. */
  1124. static Boolean
  1125. is_temp(char *k)
  1126. {
  1127.     struct trans_list *t;
  1128.  
  1129.     for (t = trans_list; t != (struct trans_list *)NULL; t = t->next) {
  1130.         if (!strcmp(t->name, k))
  1131.             return t->is_temp;
  1132.     }
  1133.     for (t = temp_keymaps; t != (struct trans_list *)NULL; t = t->next) {
  1134.         if (!strcmp(t->name, k))
  1135.             return t->is_temp;
  1136.     }
  1137.     return False;
  1138. }
  1139.  
  1140. /* Return the pathname associated with a keymap. */
  1141. static char *
  1142. pathname(char *k)
  1143. {
  1144.     struct trans_list *t;
  1145.  
  1146.     for (t = trans_list; t != (struct trans_list *)NULL; t = t->next) {
  1147.         if (!strcmp(t->name, k))
  1148.             return t->pathname;
  1149.     }
  1150.     for (t = temp_keymaps; t != (struct trans_list *)NULL; t = t->next) {
  1151.         if (!strcmp(t->name, k))
  1152.             return t->pathname;
  1153.     }
  1154.     return CN;
  1155. }
  1156.  
  1157. /* Return whether or not a keymap was translated from "@server". */
  1158. static Boolean
  1159. from_server(char *k)
  1160. {
  1161.     struct trans_list *t;
  1162.  
  1163.     for (t = trans_list; t != (struct trans_list *)NULL; t = t->next) {
  1164.         if (!strcmp(t->name, k))
  1165.             return t->from_server;
  1166.     }
  1167.     for (t = temp_keymaps; t != (struct trans_list *)NULL; t = t->next) {
  1168.         if (!strcmp(t->name, k))
  1169.             return t->from_server;
  1170.     }
  1171.     return False;
  1172. }
  1173.  
  1174. /*
  1175.  * Comparison function for keymaps.
  1176.  */
  1177. static int
  1178. keymap_cmp(char *k1, int l1, char *k2, int l2)
  1179. {
  1180.     /* If the keymaps are the same, do a numerical comparison. */
  1181.     if (!strcmp(k1, k2))
  1182.         return l1 - l2;
  1183.  
  1184.  
  1185.     /* The keymaps are different.  Order them according to trans_list. */
  1186.     return km_index(k1) - km_index(k2);
  1187. }
  1188.  
  1189. /*
  1190.  * strcmp() that handles <KeyPress>Fnn numercally.
  1191.  */
  1192. static int
  1193. Fnn_strcmp(char *s1, char *s2)
  1194. {
  1195.     static char kp[] = "<KeyPress>F";
  1196. #    define KPL (sizeof(kp) - 1)
  1197.  
  1198.     if (strncmp(s1, kp, KPL) || !isdigit(s1[KPL]) ||
  1199.         strncmp(s2, kp, KPL) || !isdigit(s2[KPL]))
  1200.         return strcmp(s1, s2);
  1201.     return atoi(s1 + KPL) - atoi(s2 + KPL);
  1202. }
  1203.  
  1204. /*
  1205.  * Comparison function for events.
  1206.  */
  1207. static int
  1208. event_cmp(char *e1, char *e2)
  1209. {
  1210.     char *l1, *l2;
  1211.     int r;
  1212.  
  1213.     /* If either has a syntax problem, do a straight string compare. */
  1214.     if ((l1 = strchr(e1, '<')) == CN ||
  1215.         (l2 = strchr(e2, '<')) == CN)
  1216.         return strcmp(e1, e2);
  1217.  
  1218.     /*
  1219.      * If the events are different, sort on the event only.  Otherwise,
  1220.      * sort on the modifier(s).
  1221.      */
  1222.     r = Fnn_strcmp(l1, l2);
  1223.     if (r)
  1224.         return r;
  1225.     else
  1226.         return strcmp(e1, e2);
  1227. }
  1228. #endif /*]*/
  1229.